home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d912.lha / Yak / Source / Source.lha / help.c < prev    next >
C/C++ Source or Header  |  1993-07-31  |  13KB  |  611 lines
  1. /*
  2.  * help.c
  3.  * 
  4.  * Opens help/settings window and handles events.
  5.  * For yak.
  6.  * 
  7.  * Martin W. Scott, 12-Sep-92.
  8.  */
  9. #include <exec/types.h>
  10. #include <dos/dosextens.h>
  11. #include <graphics/gfxmacros.h>
  12. #include <libraries/commodities.h>
  13. #include <intuition/gadgetclass.h>
  14. #include <intuition/intuition.h>
  15. #include <libraries/gadtools.h>
  16. #include <proto/exec.h>
  17. #include <proto/dos.h>
  18. #include <proto/intuition.h>
  19. #include <proto/gadtools.h>
  20. #include <proto/graphics.h>
  21. #include <proto/commodities.h>
  22. #include <string.h>
  23.  
  24. #include "yak.h"
  25. #include "hotkey_types.h"
  26. #include "popup.h"
  27. #include "version.h"
  28.  
  29. extern struct DosLibrary *DOSBase ;
  30. static struct Window *curwin;
  31.  
  32. /* static protos */
  33. static void __regargs InitHelpGadget(UWORD num, LONG tagtype, LONG tagvalue);
  34. static void InitHelpGadgets(void);
  35. static void __regargs InitHotKeyGadget(UWORD num, LONG tagtype, LONG tagvalue);
  36. static void InitHotKeyGadgets(void);
  37. static void __regargs NewPattern(UWORD gdx, UWORD n, struct Gadget *gad);
  38. static BOOL ShowHelpWindow(void);
  39. static BOOL ShowHotKeyWindow(void);
  40. static BOOL SwitchWindows(void);
  41. static LONG HandleHelpIDCMP(void);
  42. static LONG HandleHotKeyIDCMP(void);
  43.  
  44.  
  45. /* menu numbers */
  46. #define LOAD 0
  47. #define SAVE 1
  48. #define HIDE 2
  49. #define QUIT 3
  50.  
  51. /* initialise individual gadget in help window */
  52. static void __regargs
  53. InitHelpGadget(UWORD num, LONG tagtype, LONG tagvalue)
  54. {
  55.     GT_SetGadgetAttrs(HelpGadgets[num], HelpWnd, NULL, tagtype, tagvalue, TAG_DONE);
  56. }
  57.  
  58. /* initialise all gadgets */
  59. static void
  60. InitHelpGadgets()
  61. {
  62.     UWORD    i;
  63.  
  64.     for (i = 0; i < NUM_TOGGLES; i++)
  65.         if (toggles[i].gadid != -1)
  66.             InitHelpGadget(toggles[i].gadid,
  67.                    GTCB_Checked,
  68.                    toggles[i].pos); 
  69.  
  70.     InitHelpGadget(GDX_MBMethod, GTCY_Active, mouseblank);
  71.     InitHelpGadget(GDX_ScrTONum, GTIN_Number, blanksecs);
  72.     InitHelpGadget(GDX_MouseTONum, GTIN_Number, mblanksecs);
  73.     InitHelpGadget(GDX_ClickVol, GTIN_Number, click_volume);
  74.     InitHelpGadget(GDX_AutoPat, GTST_String, (LONG)patterns[YP_AUTOSCR_PAT].patstr);
  75.     InitHelpGadget(GDX_ClickPat, GTST_String, (LONG)patterns[YP_CLICKSCR_PAT].patstr);
  76.     InitHelpGadget(GDX_PopPat, GTST_String, (LONG)patterns[YP_POPWIN_PAT].patstr);
  77.     InitHelpGadget(GDX_ClickWinPat, GTST_String, (LONG)patterns[YP_CLICKWIN_PAT].patstr);
  78. }
  79.  
  80. /* show current window */
  81. BOOL
  82. ShowWindow()
  83. {
  84.     WBenchToFront();
  85.     if (curwin)        /* already open... */
  86.     {
  87.         WindowToFront(curwin);
  88.         ActivateWindow(curwin);
  89.         return TRUE;
  90.     }
  91.  
  92.     if (SetupScreen())    /* try to get lock on WB */
  93.         return FALSE;
  94.  
  95.     return ShowHelpWindow();
  96. }
  97.  
  98. /* show our help window */
  99. static BOOL
  100. ShowHelpWindow()
  101. {
  102.     static char    title[80];
  103.  
  104.     strcpy(title, VERSION_NAME ": HotKey = <");
  105.     strcat(title, PopKeyStr);
  106.     strcat(title, ">");
  107.     HelpWdt = title;
  108.     InitGUI ();
  109.  
  110.     if (!OpenHelpWindow())    /* like the name says... */
  111.     {
  112.         InitHelpGadgets();
  113.         wndsigflag = 1 << HelpWnd->UserPort->mp_SigBit;
  114.         curwin = HelpWnd;
  115.         return TRUE;
  116.     }
  117.     CloseDownScreen();
  118.     return FALSE;
  119. }
  120.  
  121. /* show our help window */
  122. static BOOL
  123. ShowHotKeyWindow()
  124. {
  125.     if (!OpenHotKeyWindow())    /* like the name says... */
  126.     {
  127.         InitHotKeyGadgets();
  128.         wndsigflag = 1 << HotKeyWnd->UserPort->mp_SigBit;
  129.         curwin = HotKeyWnd;
  130.         return TRUE;
  131.     }
  132.     CloseDownScreen();
  133.     return FALSE;
  134. }
  135.  
  136. /* hide our window */
  137. void
  138. HideWindow()
  139. {
  140.     if (curwin)
  141.     {
  142.         if (curwin == HelpWnd)
  143.             CloseHelpWindow();
  144.         else
  145.             CloseHotKeyWindow();
  146.  
  147.         CloseDownScreen();
  148.         wndsigflag = NULL;
  149.         curwin = HelpWnd = HotKeyWnd = NULL;
  150.     }
  151. }
  152.  
  153. /* switch between windows */
  154. static BOOL
  155. SwitchWindows()
  156. {
  157.     if (curwin == HelpWnd)
  158.     {
  159.         HelpLeft = HotKeyLeft = HelpWnd->LeftEdge;
  160.         HelpTop = HotKeyTop = HelpWnd->TopEdge;
  161.         CloseHelpWindow();
  162.         return ShowHotKeyWindow();
  163.     } else {
  164.         CloseHotKeyWindow();
  165.         return ShowHelpWindow();
  166.     }
  167. }
  168.  
  169. /* handle pattern string-gadget */
  170. static void __regargs
  171. NewPattern(UWORD gdx, UWORD n, struct Gadget *gad)
  172. {
  173.     char *newpatstr;
  174.  
  175.     newpatstr = GetString(gad);
  176.     if (!InitPattern(newpatstr, n))
  177.     {
  178.         DisplayBeep(Scr);
  179.         InitHelpGadget(gdx, GTST_String, (LONG)patterns[n].patstr);
  180.     }
  181. }
  182.  
  183. /* handle window events */
  184. LONG
  185. HandleIDCMP()
  186. {
  187.     if (curwin == HelpWnd)
  188.         return HandleHelpIDCMP();
  189.     else
  190.         return HandleHotKeyIDCMP();
  191. }
  192.  
  193. /* handle help window events */
  194. static LONG
  195. HandleHelpIDCMP()
  196. {
  197.     struct IntuiMessage *msg;
  198.     struct Gadget   *gadget;
  199.     ULONG           class;
  200.     UWORD        code;
  201.     LONG        num;
  202.  
  203.     while (msg = GT_GetIMsg(HelpWnd->UserPort))
  204.     {
  205.         class = msg->Class;
  206.         code = msg->Code;
  207.         gadget = (struct Gadget *)msg->IAddress;
  208.         GT_ReplyIMsg(msg);
  209.  
  210.         switch (class)
  211.         {
  212.         case CLOSEWINDOW:
  213.             HideWindow();
  214.             return HELP_OKAY;
  215.  
  216.         case GADGETUP:
  217.         case GADGETDOWN:
  218.             switch (gadget->GadgetID)
  219.             {
  220.             case GD_EditHotkeys: 
  221.                 if (!SwitchWindows())
  222.                     PostError("Couldn't open other window");
  223.                 return HELP_OKAY;
  224.  
  225.             case GD_AutoPat:
  226.                 NewPattern(GDX_AutoPat, YP_AUTOSCR_PAT, gadget);
  227.                 break;
  228.  
  229.             case GD_ClickPat:
  230.                 NewPattern(GDX_ClickPat, YP_CLICKSCR_PAT, gadget);
  231.                 break;
  232.  
  233.             case GD_PopPat:
  234.                 NewPattern(GDX_PopPat, YP_POPWIN_PAT, gadget);
  235.                 break;
  236.  
  237.             case GD_ClickWinPat:
  238.                 NewPattern(GDX_ClickWinPat, YP_CLICKWIN_PAT, gadget);
  239.                 break;
  240.  
  241.             case GD_Hide:
  242.                 HideWindow();
  243.                 return HELP_OKAY;
  244.  
  245.             case GD_Quit:
  246.                 HideWindow();
  247.                 return HELP_QUIT;
  248.  
  249.             case GD_AutoCheck:    /* toggle */
  250.                 autopoint ^= TRUE;
  251.                 break;
  252.  
  253.             case GD_AutoPopCheck:    /* toggle */
  254.                 autopop ^= TRUE;
  255.                 break;
  256.  
  257.             case GD_KeyActCheck:    /* toggle */
  258.                 keyactivate ^= TRUE;
  259.                 break;
  260.  
  261.             case GD_CTFCheck:    /* toggle */
  262.                 clicktofront ^= TRUE;
  263.                 break;
  264.  
  265.             case GD_CTBCheck:    /* toggle */
  266.                 clicktoback ^= TRUE;
  267.                 break;
  268.  
  269.             case GD_ScrCycleCheck:    /* toggle */
  270.                 screencycle ^= TRUE;
  271.                 break;
  272.  
  273.             case GD_WildStarCheck:    /* toggle */
  274.                 wildstar ^= TRUE;
  275.                 if (wildstar) WILDSTARON; else WILDSTAROFF;
  276.                 break;
  277.  
  278.             case GD_ScrActCheck:    /* toggle */
  279.                 scractivate ^= TRUE;
  280.                 break;
  281.  
  282.             case GD_RMBActCheck:    /* toggle */
  283.                 rmbactivate ^= TRUE;
  284.                 break;
  285.  
  286.             case GD_ScrTONum:
  287.                 num = GetNumber(gadget);
  288.                 if (num >= 0) {
  289.                     blanksecs = num;
  290.                     blankcount = blanktimeout = blanksecs*10;
  291.                 } else {
  292.                     InitHelpGadget(GDX_ScrTONum, GTIN_Number, blanksecs);
  293.                     DisplayBeep(HelpWnd->WScreen);
  294.                 }
  295.                 break;
  296.  
  297.             case GD_MouseTONum:
  298.                 num = GetNumber(gadget);
  299.                 if (num >= 0) {
  300.                     mblanksecs = num;
  301.                     mblankcount = mblanktimeout = mblanksecs*10;
  302.                 } else {
  303.                     InitHelpGadget(GDX_MouseTONum, GTIN_Number, mblanksecs);
  304.                     DisplayBeep(HelpWnd->WScreen);
  305.                 }
  306.                 break;
  307.  
  308.             case GD_ClickVol:
  309.                 num = GetNumber(gadget);
  310.                 if (num >= 0 && num <= 64) {
  311.                     click_volume = num;
  312.                 } else {
  313.                     InitHelpGadget(GDX_ClickVol, GTIN_Number, click_volume);
  314.                     DisplayBeep(HelpWnd->WScreen);
  315.                 }
  316.                 break;
  317.  
  318.             case GD_MBMethod:
  319.                 mouseblank = code;
  320.                 mblankcount = mblanktimeout;
  321.                 break;
  322.  
  323.             } /* switch (gadget->GadgetID) */
  324.             break;
  325.  
  326.         case REFRESHWINDOW:
  327.             GT_BeginRefresh(HelpWnd);
  328.             HelpRender();
  329.             GT_EndRefresh(HelpWnd, TRUE);
  330.             break;
  331.  
  332.         case IDCMP_MENUPICK:
  333.             while (code != MENUNULL) 
  334.             {
  335.                 struct MenuItem *item = ItemAddress(HelpMenus, code);
  336.  
  337.                 switch (ITEMNUM(code))
  338.                 {
  339.                 case LOAD:
  340.                     LoadSettings();
  341.                     InitHelpGadgets();
  342.                     break;
  343.                 case SAVE:
  344.                     SaveSettings();
  345.                     break;
  346.                 case HIDE:
  347.                     HideWindow();
  348.                     return HELP_OKAY;
  349.                 case QUIT:
  350.                     HideWindow();
  351.                     return HELP_QUIT;
  352.                 }
  353.                 code = item->NextSelect;
  354.  
  355.             } /* while more menuchoices */
  356.             break;
  357.  
  358.         } /* switch (class) */
  359.  
  360.     } /* while more messages */
  361.  
  362.     return HELP_OKAY;
  363. }
  364.  
  365. /*******************************************************************************
  366.  *    HOTKEY SPECIFIC DATA/ROUTINES
  367.  *    perhaps move to another file?
  368.  *******************************************************************************/
  369.  
  370. /* prototypes */
  371. static struct Node *GetNode(struct List *lh, UWORD n);
  372. static UWORD GetNodeNum(struct List *lh, struct Node *node);
  373.  
  374. /* external data */
  375. static YakHotKey    *curhk;
  376. static UWORD        curtype;
  377.  
  378. /* get nth node in list - list MUST have >= n nodes!!! */
  379. static struct Node *
  380. GetNode(struct List *lh, UWORD n)
  381. {
  382.     struct Node *ln;
  383.  
  384.     for (ln = lh->lh_Head; n--; ln = ln->ln_Succ)
  385.         ;
  386.     return ln;
  387. }
  388.  
  389. /* get number of node in list - node MUST be there! */
  390. static UWORD
  391. GetNodeNum(struct List *lh, struct Node *node)
  392. {
  393.     struct Node *ln;
  394.     UWORD i;
  395.  
  396.     for (i = 0, ln = lh->lh_Head; ln != node; ln = ln->ln_Succ, i++)
  397.         ;
  398.     return i;
  399. }
  400.  
  401. /* initialise individual gadget in hotkey window */
  402. static void __regargs
  403. InitHotKeyGadget(UWORD num, LONG tagtype, LONG tagvalue)
  404. {
  405.     GT_SetGadgetAttrs(HotKeyGadgets[num], HotKeyWnd, NULL, tagtype, tagvalue, TAG_DONE);
  406. }
  407.  
  408. /* initialise all gadgets */
  409. static void
  410. InitHotKeyGadgets()
  411. {
  412.     InitHotKeyGadget(GDX_Hotkeys, GTLV_Labels, (LONG)keylist(curtype));
  413.     InitHotKeyGadget(GDX_Actions, GTLV_Selected, curtype);
  414.  
  415.     InitHotKeyGadget(GDX_Delete, GA_Disabled, !curhk);
  416.     InitHotKeyGadget(GDX_HKStr, GA_Disabled, !curhk);
  417.  
  418.     /* something selected */
  419.     if (curhk)
  420.     {
  421.         UWORD n = GetNodeNum(keylist(curtype), (struct Node *)curhk);
  422.  
  423.         if (YHK_Has_Options(curhk))
  424.         {
  425.             InitHotKeyGadget(GDX_Options, GA_Disabled, FALSE);
  426.             InitHotKeyGadget(GDX_Options, GTCY_Active, (LONG)curhk->yhk_Options);
  427.         }
  428.  
  429.         if (YHK_Takes_Arg(curhk))
  430.         {
  431.             InitHotKeyGadget(GDX_Argument, GA_Disabled, FALSE);
  432.             InitHotKeyGadget(GDX_Argument, GTST_String, (LONG)curhk->yhk_ArgStr);
  433.         }
  434.  
  435.         InitHotKeyGadget(GDX_Hotkeys, GTLV_Selected, n);
  436.         InitHotKeyGadget(GDX_Hotkeys, GTLV_Top, n);
  437.         InitHotKeyGadget(GDX_HKStr, GTST_String, (LONG)curhk->yhk_KeyDef);
  438.     }
  439.     else    /* no current hotkey */
  440.     {
  441.         InitHotKeyGadget(GDX_HKStr, GTST_String, (LONG)"");
  442.         InitHotKeyGadget(GDX_Options, GTCY_Active, 0);
  443.         InitHotKeyGadget(GDX_Argument, GTST_String, (LONG)"");
  444.  
  445.         InitHotKeyGadget(GDX_Argument, GA_Disabled, TRUE);
  446.         InitHotKeyGadget(GDX_Options, GA_Disabled, TRUE);
  447.     }
  448. }
  449.  
  450. /* handle hotkey window events */
  451. static LONG
  452. HandleHotKeyIDCMP()
  453. {
  454.     struct IntuiMessage *msg;
  455.     struct Gadget   *gadget;
  456.     ULONG           class;
  457.     UWORD        code;
  458.  
  459.     while (msg = GT_GetIMsg(HotKeyWnd->UserPort))
  460.     {
  461.         class = msg->Class;
  462.         code = msg->Code;
  463.         gadget = (struct Gadget *)msg->IAddress;
  464.         GT_ReplyIMsg(msg);
  465.  
  466.         switch (class)
  467.         {
  468.         case CLOSEWINDOW:
  469.             HideWindow();
  470.             return HELP_OKAY;
  471.  
  472.         case VANILLAKEY:
  473.             switch (code)
  474.             {
  475.             case 'a': case 'A':    /* Add */
  476.                 goto key_a;
  477.  
  478.             case 'd': case 'D':    /* Delete */
  479.                 goto key_d;
  480.  
  481.             case 'r': case 'R':    /* Return... */
  482.                 goto key_r;
  483.  
  484.             case 'c':        /* aCtion */
  485.                 code = curtype+1;
  486.                 if (code == NUM_HOTKEY_TYPES)
  487.                     code = 0;
  488.                 goto key_c;
  489.  
  490.             case 'C':    /* aCtion */
  491.                 code = curtype-1;
  492.                 if (code == (UWORD)(-1))
  493.                     code = NUM_HOTKEY_TYPES-1;
  494.                 goto key_c;
  495.  
  496.             case 'h': case 'H':    /* Hotkey */
  497.                 if (curhk)
  498.                     ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  499.                 else if (numkeys(curtype))
  500.                 {
  501.                     code = 0;
  502.                     goto key_h;
  503.                 }
  504.                 break;
  505.  
  506.             case 't': case 'T':    /* argumenT */
  507.                 if (curhk && YHK_Takes_Arg(curhk))
  508.                     ActivateGadget(HotKeyGadgets[GDX_Argument], HotKeyWnd, NULL);
  509.                 break;
  510.  
  511.             case 'o': case 'O':    /* Options */
  512.                 if (curhk && YHK_Has_Options(curhk))
  513.                 {
  514.                     WORD sign = (code == 'o' ? 1 : -1);
  515.                     WORD newopts = curhk->yhk_Options;
  516.                     newopts += sign;
  517.                     if (newopts == -1)
  518.                         newopts = NUM_OPTIONS-1;
  519.                     else if (newopts == NUM_OPTIONS)
  520.                         newopts = 0;
  521.                     curhk->yhk_Options = newopts;
  522.                     InitHotKeyGadget(GDX_Options, GTCY_Active, (LONG)curhk->yhk_Options);
  523.                 }
  524.                 break;
  525.             }
  526.             break;
  527.  
  528.         case GADGETUP:
  529.         case GADGETDOWN:
  530.             switch (gadget->GadgetID)
  531.             {
  532.             case GD_Hotkeys:
  533.             key_h:    curhk = (YakHotKey *)GetNode(keylist(curtype), code);
  534.                 InitHotKeyGadgets();
  535.                 ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  536.                 break;
  537.  
  538.             case GD_HKStr:
  539.                 if (!curhk)    /* shouldn't happen */
  540.                     break;
  541.                 if (ModifyYHKKeyDef(curhk, GetString(gadget)))
  542.                 {
  543.                     InitHotKeyGadget(GDX_Hotkeys, GTLV_Labels, (LONG)keylist(curtype));
  544.                     if (YHK_Takes_Arg(curhk))
  545.                         ActivateGadget(HotKeyGadgets[GDX_Argument], HotKeyWnd, NULL);
  546.  
  547.                 }
  548.                 else
  549.                 {
  550.                     InitHotKeyGadgets();
  551.                     ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  552.                 }
  553.                 break;
  554.  
  555.             case GD_Argument:
  556.                 if (!curhk)    /* shouldn't happen */
  557.                     break;
  558.                 if (!(ModifyYHKArgStr(curhk, GetString(gadget))))
  559.                     InitHotKeyGadgets();
  560.                 break;
  561.  
  562.             case GD_Actions:
  563.             key_c:    if (code != curtype)
  564.                 {
  565.                     curtype = code;
  566.                     curhk = NULL;
  567.                     InitHotKeyGadgets();
  568.                 }
  569.                 break;
  570.  
  571.             case GD_Options:
  572.                 if (curhk)
  573.                     curhk->yhk_Options = code;
  574.                 break;
  575.  
  576.             case GD_Add:
  577.             key_a:    curhk = NewYakHotKey(curtype);
  578.                 InitHotKeyGadgets();
  579.                 ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  580.                 break;
  581.  
  582.             case GD_Delete:
  583.             key_d:    if (curhk)
  584.                 {
  585.                     DeleteYakHotKey(curhk);
  586.                     curhk = NULL;
  587.                     InitHotKeyGadgets();
  588.                 }
  589.                 break;
  590.  
  591.             case GD_Return:
  592.             key_r:    curhk = NULL;    /* in case of reloading */
  593.                 if (!SwitchWindows())
  594.                     PostError("Couldn't open other window");
  595.                 return HELP_OKAY;
  596.  
  597.             } /* switch (gadget->GadgetID) */
  598.             break;
  599.  
  600.         case REFRESHWINDOW:
  601.             GT_BeginRefresh(HotKeyWnd);
  602.             GT_EndRefresh(HotKeyWnd, TRUE);
  603.             break;
  604.  
  605.         } /* switch (class) */
  606.  
  607.     } /* while more messages */
  608.  
  609.     return HELP_OKAY;
  610. }
  611.